const axios = require('axios');
const io = require('socket.io-client');

// 队列服务URL
const QUEUE_SERVICE_URL = 'http://localhost:3003/api/queue/task';
const QUEUE_SERVICE_SOCKET_URL = 'http://localhost:3003';

// 创建axios实例，添加超时和重试配置
const axiosInstance = axios.create({
  timeout: 30000, // 30秒超时
  retry: 3, // 重试次数
  retryDelay: 1000 // 重试延迟
});

// 创建Socket.IO客户端
let socket;
let taskCallbacks = new Map();

// 连接到队列服务
function connectSocket() {
  if (!socket) {
    socket = io(QUEUE_SERVICE_SOCKET_URL);
    
    socket.on('connect', () => {
      console.log('🔗 已连接到队列服务');
    });
    
    socket.on('task-complete', (data) => {
      console.log(`✅ 任务完成: ${data.taskId}`, data.result);
      const callback = taskCallbacks.get(data.taskId);
      if (callback) {
        callback(null, data.result);
        taskCallbacks.delete(data.taskId);
      }
    });
    
    socket.on('task-error', (data) => {
      console.error(`❌ 任务失败: ${data.taskId}`, data.error);
      const callback = taskCallbacks.get(data.taskId);
      if (callback) {
        callback(new Error(data.error), null);
        taskCallbacks.delete(data.taskId);
      }
    });
    
    socket.on('disconnect', () => {
      console.log('🔌 与队列服务断开连接');
    });
  }
}

// 初始化连接
connectSocket();

// 添加响应拦截器处理重试
axiosInstance.interceptors.response.use(undefined, (error) => {
  const config = error.config;
  if (!config || !config.retry) return Promise.reject(error);
  
  config.__retryCount = config.__retryCount || 0;
  if (config.__retryCount >= config.retry) {
    return Promise.reject(error);
  }
  
  config.__retryCount += 1;
  const delay = new Promise(resolve => setTimeout(resolve, config.retryDelay));
  return delay.then(() => axiosInstance(config));
});

// 通过队列服务执行数据库查询
async function queryDatabase(sql, params = []) {
  try {
    // 如果Socket.IO连接可用，使用WebSocket方式
    if (socket && socket.connected) {
      return new Promise((resolve, reject) => {
        // 生成任务ID
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        
        // 注册回调
        taskCallbacks.set(taskId, (error, result) => {
          if (error) {
            reject(error);
          } else {
            // 确保返回的是数组格式
            if (Array.isArray(result)) {
              console.log(`✅ 返回数组格式数据，长度: ${result.length}`);
              resolve(result);
            } else if (result && Array.isArray(result.data)) {
              console.log(`✅ 返回嵌套数组格式数据，长度: ${result.data.length}`);
              resolve(result.data);
            } else if (result && result.success && Array.isArray(result.result)) {
              console.log(`✅ 返回结果数组格式数据，长度: ${result.result.length}`);
              resolve(result.result);
            } else {
              console.log(`⚠️  返回非数组格式数据:`, result);
              resolve([]);
            }
          }
        });
        
        // 发送任务
        socket.emit('add-task', {
          taskId: taskId,
          task: {
            type: 'db-query',
            sql: sql,
            params: params
          }
        });
      });
    } else {
      // 如果WebSocket不可用，回退到HTTP方式（但这种方式不会等待任务完成）
      console.log(`📤 发送数据库查询请求: ${sql}`, params);
      const response = await axiosInstance.post(QUEUE_SERVICE_URL, {
        task: {
          type: 'db-query',
          sql: sql,
          params: params
        }
      });
      
      console.log(`📥 收到数据库查询响应:`, response.data);
      
      // 确保返回的是数组格式
      if (Array.isArray(response.data)) {
        console.log(`✅ 返回数组格式数据，长度: ${response.data.length}`);
        return response.data;
      } else if (response.data && Array.isArray(response.data.data)) {
        console.log(`✅ 返回嵌套数组格式数据，长度: ${response.data.data.length}`);
        return response.data.data;
      } else if (response.data && response.data.success && Array.isArray(response.data.result)) {
        console.log(`✅ 返回结果数组格式数据，长度: ${response.data.result.length}`);
        return response.data.result;
      } else {
        console.log(`⚠️  返回非数组格式数据:`, response.data);
        return [];
      }
    }
  } catch (error) {
    console.error('通过队列服务查询数据库失败:', error.message);
    throw error;
  }
}

// 通过队列服务执行数据库插入
async function insertDatabase(sql, params = []) {
  try {
    // 使用WebSocket方式确保任务完成
    if (socket && socket.connected) {
      return new Promise((resolve, reject) => {
        // 生成任务ID
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        
        // 注册回调
        taskCallbacks.set(taskId, (error, result) => {
          if (error) {
            reject(error);
          } else {
            resolve(result);
          }
        });
        
        // 发送任务
        socket.emit('add-task', {
          taskId: taskId,
          task: {
            type: 'db-insert',
            sql: sql,
            params: params
          }
        });
      });
    } else {
      // 回退到HTTP方式
      const response = await axiosInstance.post(QUEUE_SERVICE_URL, {
        task: {
          type: 'db-insert',
          sql: sql,
          params: params
        }
      });
      
      return response.data;
    }
  } catch (error) {
    console.error('通过队列服务插入数据库失败:', error.message);
    throw error;
  }
}

// 通过队列服务执行数据库更新
async function updateDatabase(sql, params = []) {
  try {
    // 使用WebSocket方式确保任务完成
    if (socket && socket.connected) {
      return new Promise((resolve, reject) => {
        // 生成任务ID
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        
        // 注册回调
        taskCallbacks.set(taskId, (error, result) => {
          if (error) {
            reject(error);
          } else {
            resolve(result);
          }
        });
        
        // 发送任务
        socket.emit('add-task', {
          taskId: taskId,
          task: {
            type: 'db-update',
            sql: sql,
            params: params
          }
        });
      });
    } else {
      // 回退到HTTP方式
      const response = await axiosInstance.post(QUEUE_SERVICE_URL, {
        task: {
          type: 'db-update',
          sql: sql,
          params: params
        }
      });
      
      return response.data;
    }
  } catch (error) {
    console.error('通过队列服务更新数据库失败:', error.message);
    throw error;
  }
}

// 通过队列服务执行数据库删除
async function deleteDatabase(sql, params = []) {
  try {
    // 使用WebSocket方式确保任务完成
    if (socket && socket.connected) {
      return new Promise((resolve, reject) => {
        // 生成任务ID
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        
        // 注册回调
        taskCallbacks.set(taskId, (error, result) => {
          if (error) {
            reject(error);
          } else {
            resolve(result);
          }
        });
        
        // 发送任务
        socket.emit('add-task', {
          taskId: taskId,
          task: {
            type: 'db-delete',
            sql: sql,
            params: params
          }
        });
      });
    } else {
      // 回退到HTTP方式
      const response = await axiosInstance.post(QUEUE_SERVICE_URL, {
        task: {
          type: 'db-delete',
          sql: sql,
          params: params
        }
      });
      
      return response.data;
    }
  } catch (error) {
    console.error('通过队列服务删除数据库失败:', error.message);
    throw error;
  }
}

// 通过队列服务执行数据库事务
async function executeTransaction(operations) {
  try {
    // 使用WebSocket方式确保任务完成
    if (socket && socket.connected) {
      return new Promise((resolve, reject) => {
        // 生成任务ID
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        
        // 注册回调
        taskCallbacks.set(taskId, (error, result) => {
          if (error) {
            reject(error);
          } else {
            resolve(result);
          }
        });
        
        // 发送任务
        socket.emit('add-task', {
          taskId: taskId,
          task: {
            type: 'db-transaction',
            operations: operations
          }
        });
      });
    } else {
      // 回退到HTTP方式
      const response = await axiosInstance.post(QUEUE_SERVICE_URL, {
        task: {
          type: 'db-transaction',
          operations: operations
        }
      });
      
      return response.data;
    }
  } catch (error) {
    console.error('通过队列服务执行数据库事务失败:', error.message);
    throw error;
  }
}

module.exports = {
  queryDatabase,
  insertDatabase,
  updateDatabase,
  deleteDatabase,
  executeTransaction
};